home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 19 / CU Amiga Magazine's Super CD-ROM 19 (1998)(EMAP Images)(GB)[!][issue 1998-02].iso / CUCD / Online / NNTPd / server / misc.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-10-15  |  22.1 KB  |  1,064 lines
  1. #ifndef lint
  2. static char    sccsid[] = "@(#)$Id: misc.c,v 1.47 1995/01/01 03:39:24 sob Exp sob $";
  3. #endif
  4.  
  5. #include "common.h"
  6.  
  7. /* forward declarations */
  8. void close_crnt();
  9. void get_id();
  10.  
  11. /*
  12.  * open_valid_art -- determine if a given article name is valid;
  13.  *        if it is, return a file pointer to the open article,
  14.  *        along with a unique id of the article.
  15.  *
  16.  *    Parameters:    "artname" is a string containing the
  17.  *            name of the article.
  18.  *            "id" is space for us to put the article
  19.  *            id in.
  20.  *
  21.  *    Returns:    File pointer to the open article if the
  22.  *            article is valid; NULL otherwise
  23.  *
  24.  *    Side effects:    None.
  25.  */
  26.  
  27. FILE *
  28. open_valid_art(artname, id)
  29.     char        *artname;
  30.     char        *id;
  31. {
  32.     static int    crnt_art_num;
  33.     static char    crnt_art_id[MAXBUFLEN];
  34.     int        fd;
  35.     struct stat    statbuf;
  36.  
  37.     if (art_fp != NULL) {
  38.         if (crnt_art_num == atoi(artname)) {
  39.             if (fseek(art_fp, (long) 0, 0) < 0)
  40.                 close_crnt();
  41.             else {
  42.                 (void) strcpy(id, crnt_art_id);
  43.                 return (art_fp);
  44.             }
  45.         } else 
  46.             close_crnt();
  47.     }
  48.  
  49.     art_fp = fopen(artname, "r");
  50.  
  51.     if (art_fp == NULL)
  52.         return (NULL);
  53.  
  54.     fd = fileno(art_fp);
  55.  
  56.     if (fstat(fd, &statbuf) < 0) {
  57.         close_crnt();
  58.         return (NULL);
  59.     }
  60.  
  61.     if ((statbuf.st_mode & S_IFMT) != S_IFREG) {
  62.         close_crnt();
  63.         return (NULL);
  64.     }
  65.  
  66.     get_id(art_fp, id);
  67.     (void) strcpy(crnt_art_id, id);
  68.     crnt_art_num = atoi(artname);
  69.     return (art_fp);
  70. }
  71.  
  72.  
  73. /*
  74.  * gethistent -- return the path name of an article if it's
  75.  * in the history file.
  76.  *
  77.  *    Parameters:    "msg_id" is the message ID of the
  78.  *            article, enclosed in <>'s.
  79.  *            "lookup", only check if article exists
  80.  *
  81.  *    Returns:    A char pointer to a static data area
  82.  *            containing the full pathname of the
  83.  *            article, or NULL if the message-id is not
  84.  *            in the history file.
  85.  *
  86.  *    Side effects:    opens dbm database
  87.  *            (only once, keeps it open after that).
  88.  *            If running Bnews, converts "msg_id" to lower case.
  89.  *            If running Cnews, converts "msg_id" per rfc822.
  90.  *            If in a group, sets group_artnum to appropriate value.
  91.  *            
  92.  */
  93.  
  94. #ifndef NDBM
  95. # ifndef DBM
  96. #  ifndef USGHIST
  97. #   define USGHIST
  98. #  endif
  99. # endif
  100. #endif
  101.  
  102. char *
  103. gethistent(msg_id, lookup)
  104.     char        *msg_id;
  105.     int        lookup;
  106. {
  107.     char        line[MAXBUFLEN];
  108.     char        *tmp;
  109.     register char    *cp;
  110.     char        *s;
  111.     long        ltmp;
  112.     static char    path[MAXPATHLEN];
  113. #ifdef USGHIST
  114.     char        *histfile();
  115.     register int    len;
  116. #else
  117. #ifdef DBM
  118.     static int    dbopen = 0;
  119.     datum        fetch();
  120. #else
  121.     static DBM    *db = NULL;    /* History file, dbm version */
  122. #endif /* !DBM */
  123.     datum         key, content;
  124. #endif /* !USGHIST */
  125.     static FILE    *hfp = NULL;    /* history file, text version */
  126.  
  127. #ifdef CNEWS
  128.     cp = rindex(msg_id,'@');    /* look for @ in message id */
  129.     if( cp != NULL)
  130.     {    
  131.         for(;*cp != '\0';++cp)
  132. #else
  133.     {
  134.         for (cp = msg_id; *cp != '\0'; ++cp)
  135. #endif
  136.         if (isupper(*cp))
  137.             *cp = tolower(*cp);
  138. /* Make ctags happy */
  139. #ifdef CNEWS
  140.     }
  141. #else
  142.     }
  143. #endif
  144. #ifdef USGHIST
  145.     hfp = fopen(histfile(msg_id), "r");
  146.     if (hfp == NULL) {
  147. #ifdef SYSLOG
  148.         syslog(LOG_ERR, "gethistent: histfile: %m");
  149. #endif
  150.         return (NULL);
  151.     }
  152.  
  153.     len = strlen(msg_id);
  154.     while (fgets(line, sizeof (line), hfp))
  155.         if (!strncasecmp(msg_id, line, len))
  156.             break;
  157.  
  158.     if (feof(hfp)) {
  159.         (void) fclose(hfp);
  160.         return (NULL);
  161.     }
  162. #else /* !USGHIST */
  163. #ifdef DBM
  164.     if (!dbopen) {
  165.         if (dbminit(historyfile) < 0) {
  166. #ifdef SYSLOG
  167.             syslog(LOG_ERR, "openartbyid: dbminit %s: %m",
  168.                 historyfile);
  169. #endif
  170.             return (NULL);
  171.         } else
  172.             dbopen = 1;
  173.     }
  174. #else /* !DBM (ndbm) */
  175.     if (db == NULL) {
  176.         db = dbm_open(historyfile, O_RDONLY, 0);
  177.         if (db == NULL) {
  178. #ifdef SYSLOG
  179.             syslog(LOG_ERR, "openartbyid: dbm_open %s: %m",
  180.                 historyfile);
  181. #endif
  182.             return (NULL);
  183.         }
  184.     }
  185. #endif /* !DBM */
  186.  
  187.     key.dptr = msg_id;
  188.     key.dsize = strlen(msg_id) + 1;
  189.  
  190. #ifdef DBM
  191.     content = fetch(key);
  192. #else /* !DBM (ndbm) */
  193.     content = dbm_fetch(db, key);
  194. #endif
  195.     if (content.dptr == NULL)
  196.         return (NULL);
  197.  
  198.     /*
  199.      * If we are just checking to see if it exists return a non-NULL
  200.      * result
  201.      */
  202.     if (lookup)
  203.         return ((char *)1);
  204.  
  205.     if (hfp == NULL) {
  206.         hfp = fopen(historyfile, "r");
  207.         if (hfp == NULL) {
  208. #ifdef SYSLOG
  209.             syslog(LOG_ERR, "message: fopen %s: %m",
  210.                 historyfile);
  211. #endif
  212.             return (NULL);
  213.         }
  214.     } else {
  215. /* Why do this if we are going to do an absolute fseek below? XXX */
  216.         rewind(hfp);
  217.     }
  218.  
  219.     bcopy(content.dptr, (char *)<mp, sizeof (long));
  220.     if (fseek(hfp, ltmp, 0) < 0) {
  221. #ifdef SYSLOG
  222.         syslog(LOG_ERR, "message: %s: fseek to %ld on %d: %m", 
  223.                historyfile, ltmp, hfp);
  224. #endif
  225.         return (NULL);
  226.     }
  227.  
  228.     (void) fgets(line, sizeof(line), hfp);
  229. #endif /* USGHIST */
  230.  
  231.     if ((cp = index(line, '\n')) != NULL)
  232.         *cp = '\0';
  233.     cp = index(line, '\t');
  234.     if (cp != NULL)
  235.         cp = index(cp+1, '\t');
  236. #ifdef SYSLOG
  237.     else
  238.         syslog(LOG_ERR,
  239.         "message: malformed line in history file at %ld bytes, id %s",
  240.             ltmp, msg_id);
  241. #endif
  242.     if (cp == NULL) return(NULL); /* this article has expired */
  243.     tmp = cp+1;
  244.     group_artnum = 0;
  245.     if (group_name) {
  246.         int glen = strlen(group_name);
  247.         for (;;) {
  248.             if (!strncmp(group_name,tmp,glen) && tmp[glen] == '/') {
  249.                 group_artnum = atol(tmp+glen+1);
  250.                 break;
  251.             }
  252.             cp = index(tmp, ' ');
  253.             if (cp == NULL) break;
  254.             tmp = cp+1;
  255.         }
  256.     }
  257.  
  258.     if ((cp = index(tmp, ' ')) != NULL)
  259.         *cp = '\0';
  260.     
  261.     while ((cp = index(tmp, '.')) != NULL)
  262.         *cp = '/';
  263.  
  264.     (void) strcpy(path, spooldir);
  265.     (void) strcat(path, "/");
  266.     (void) strcat(path, tmp);
  267. #ifdef USGHIST
  268.     (void) fclose(hfp);
  269. #endif
  270.     return (path);
  271. }
  272.  
  273. /*
  274.  * openartbyid -- open an article by message-id.
  275.  *
  276.  *    Arguments:    "msg_id" is the message-id of the article
  277.  *            to open.
  278.  *
  279.  *    Returns:    File pointer to opened article, or NULL if
  280.  *            the article was not in the history file or
  281.  *            could not be opened.
  282.  *
  283.  *    Side effects:    Opens article.
  284.  */
  285.  
  286. FILE *
  287. openartbyid(msg_id)
  288.     char    *msg_id;
  289. {
  290.     char    *path;
  291.  
  292.     path = gethistent(msg_id, 0);
  293.     if (path != NULL)
  294.         return (fopen(path, "r"));
  295.     else
  296.         return (NULL);
  297. }
  298.  
  299.  
  300. /*
  301.  * check_ngperm -- check to see if they're allowed to see this
  302.  * article by matching Newsgroups: and Distribution: line.
  303.  *
  304.  *    Parameters:    "fp" is the file pointer of this article.
  305.  *
  306.  *    Returns:    0 if they're not allowed to see it.
  307.  *            1 if they are.
  308.  *
  309.  *    Side effects:    None.
  310.  */
  311.  
  312. int
  313. check_ngperm(fp)
  314.     register FILE    *fp;
  315. {
  316.     char        buf[MAXBUFLEN];
  317.     register char    *cp;
  318.     static char    **ngarray;
  319.     int        ngcount = 0;
  320.  
  321.     if (ngpermcount == 0) {
  322.         if (ALLBUT == 0)
  323.             return 0;
  324.         return (1);
  325.     }
  326.  
  327.     while (fgets(buf, sizeof (buf), fp) != NULL) {
  328.         if (buf[0] == '\n')        /* End of header */
  329.             break;
  330.         if (buf[0] != 'N' && buf[0] != 'n')
  331.             continue;
  332.         cp = index(buf, '\n');
  333.         if (cp)
  334.             *cp = '\0';
  335.         cp = index(buf, ':');
  336.         if (cp == NULL)
  337.             continue;
  338.         *cp = '\0';
  339.         if (!strcasecmp(buf, "newsgroups")) {
  340.             ngcount = get_nglist(&ngarray, cp+2);
  341.             break;
  342.         }
  343.     }
  344.  
  345. #ifndef USG
  346.     (void) rewind(fp);
  347. #else
  348.     rewind(fp);
  349. #endif
  350.     if (ngcount == 0)    /* Either no newgroups or null entry */
  351.         return (1);
  352.  
  353.     return (ngmatch(s1strneql, ALLBUT,
  354.         ngpermlist, ngpermcount, ngarray, ngcount));
  355. }
  356.  
  357.  
  358. /*
  359.  * spew -- spew out the contents of a file to stdout, doing
  360.  * the necessary cr-lf additions at the end.  Finish with
  361.  * a "." on a line by itself, and an fflush(stdout).
  362.  *
  363.  *    Parameters:    "how" tells what part of the file we
  364.  *            want spewed:
  365.  *                ARTICLE   The entire thing.
  366.  *                HEAD      Just the first part.
  367.  *                BODY      Just the second part.
  368.  *            "fp" is the open file to spew from.
  369.  *
  370.  *    Returns:    Nothing.
  371.  *
  372.  *    Side effects:    Changes current position in file.
  373.  */
  374.  
  375. void
  376. spew(fp, how)
  377.     FILE        *fp;
  378.     int        how;
  379. {
  380.     char        line[NNTP_STRLEN];
  381.     register char    *cp;
  382.  
  383. #ifdef LOG
  384.     ++arts_acsd;
  385. #endif
  386.  
  387.     if (how == STAT) {
  388.         (void) fflush(stdout);
  389.         return;
  390.     }
  391.  
  392.     cp = line;
  393.     while (fgets(line, sizeof(line)-6, fp) != NULL
  394.         && (cp == NULL || *line != '\n')) {
  395.         if (how == BODY)    /* We need to skip this anyway */
  396.             continue;
  397.         if (cp != NULL && *line == '.')
  398.             putchar('.');
  399.         cp = index(line, '\n');
  400.         if (cp != NULL)
  401.             *cp = '\0';
  402.         fputs(line, stdout);
  403.         if (cp != NULL) {
  404.             putchar('\r');
  405.             putchar('\n');
  406.         }
  407.     }
  408.  
  409.     if (how == HEAD) {
  410.         putline(".");
  411.         (void) fflush(stdout);
  412.         return;
  413.     }
  414.     if (how == ARTICLE) {
  415.         putchar('\r');
  416.         putchar('\n');
  417.     }
  418.  
  419.     while (fgets(line, sizeof(line)-6, fp) != NULL) {
  420.         if (cp != NULL && *line == '.')
  421.             putchar('.');
  422.         cp = index(line, '\n');
  423.         if (cp != NULL)
  424.             *cp = '\0';
  425.         fputs(line, stdout);
  426.         if (cp != NULL) {
  427.             putchar('\r');
  428.             putchar('\n');
  429.         }
  430.     }
  431.     if (cp == NULL) {
  432.         putchar('\r');
  433.         putchar('\n');
  434.     }
  435.     putline(".");
  436.     (void) fflush(stdout);
  437. }
  438.  
  439.  
  440. /*
  441.  * get_id -- get the message id of the current article.
  442.  *
  443.  *    Parameters:    "art_fp" is a pointer to the open file.
  444.  *            "id" is space for the message ID.
  445.  *
  446.  *    Returns:    Nothing.
  447.  *
  448.  *    Side effects:    Seeks and rewinds on "art_fp".
  449.  *            Changes space pointed to by "id".
  450.  */
  451.  
  452. void
  453. get_id(art_fp, id)
  454.     register FILE    *art_fp;
  455.     char        *id;
  456. {
  457.     char        line[MAXBUFLEN];
  458.     register char    *cp;
  459.  
  460.     while (fgets(line, sizeof(line), art_fp) != NULL) {
  461.         if (*line == '\n')
  462.             break;
  463.         if (*line == 'M' || *line == 'm') {    /* "Message-ID" */
  464.             if ((cp = index(line, ' ')) != NULL) {
  465.                 *cp = '\0';
  466.                 if (!strcasecmp(line, "Message-ID:")) {
  467.                     (void) strcpy(id, cp + 1);
  468.                     if ((cp = index(id, '\n')) != NULL)
  469.                         *cp = '\0';
  470. #ifndef USG
  471.                     (void) rewind(art_fp);
  472. #else
  473.                     rewind(art_fp);
  474. #endif
  475.                     return;
  476.                 }
  477.             }
  478.         }
  479.     }
  480. #ifndef USG
  481.     (void) rewind(art_fp);
  482. #else
  483.     rewind(art_fp);
  484. #endif
  485.     (void) strcpy(id, "<0>");
  486. }
  487.         
  488.  
  489. /*
  490.  * close_crnt -- close the current article file pointer, if it's
  491.  *    open.
  492.  *
  493.  *    Parameters:    None.
  494.  *
  495.  *    Returns:    Nothing.
  496.  *
  497.  *    Side effects:    Closes "art_fp" if it's open; sets "art_fp" to NULL.
  498.  */
  499.  
  500. void
  501. close_crnt()
  502. {
  503.     if (art_fp != NULL)
  504.         (void) fclose(art_fp);
  505.     art_fp = NULL;
  506. }
  507.  
  508.  
  509. /*
  510.  * findart -- find an article number in the article array.
  511.  *
  512.  *    Parameters:    "artname" is a string containing
  513.  *            the name of the article.
  514.  *
  515.  *    Returns:    An index into "art_array",
  516.  *            or -1 if "artname" isn't in "art_array".
  517.  *            
  518.  *    Side effects:    None.
  519.  *
  520.  *    Improvement:    Replace this linear search with a binary one.
  521.  */
  522.  
  523. int
  524. findart(artname)
  525.     char        *artname;
  526. {
  527.     register int    i, artnum;
  528.  
  529.     artnum = atoi(artname);
  530.  
  531.     for (i = 0; i < num_arts; ++i)
  532.         if (art_array[i] == artnum)
  533.             return(i);
  534.  
  535.     return (-1);
  536. }
  537.  
  538.  
  539. /*
  540.  * get_distlist -- return a nicely set up array of distribution groups
  541.  * along with a count, when given an NNTP-spec distribution list
  542.  * in the form <dist1,dist2,...,distn>.
  543.  *
  544.  *    Parameters:        "array" is storage for our array,
  545.  *                set to point at some static data.
  546.  *                "list" is the NNTP distribution list.
  547.  *
  548.  *    Returns:        Number of distributions found.
  549.  *                -1 on error.
  550.  *
  551.  *    Side effects:        Changes static data area.
  552.  */
  553.  
  554. int
  555. get_distlist(array, list)
  556.     char        ***array;
  557.     char        *list;
  558. {
  559.     char        *cp;
  560.     int        distcount;
  561.     static char    **dist_list = (char **) NULL;
  562.  
  563.     if (list[0] != '<')
  564.         return (-1);
  565.  
  566.     cp = index(list + 1, '>');
  567.     if (cp != NULL)
  568.         *cp = '\0';
  569.     else
  570.         return (-1);
  571.  
  572.     for (cp = list + 1; *cp != '\0'; ++cp)
  573.         if (*cp == ',')
  574.             *cp = ' ';
  575.     distcount = parsit(list + 1, &dist_list);
  576.     *array = dist_list;
  577.     return (distcount);
  578. }
  579.  
  580.  
  581. /*
  582.  * lower -- convert a character to lower case, if it's upper case.
  583.  *
  584.  *    Parameters:    "c" is the character to be
  585.  *            converted.
  586.  *
  587.  *    Returns:    "c" if the character is not
  588.  *            upper case, otherwise the lower
  589.  *            case equivalent of "c".
  590.  *
  591.  *    Side effects:    None.
  592.  */
  593.  
  594. char
  595. lower(c)
  596.     register char    c;
  597. {
  598.     if (isascii(c) && isupper(c))
  599.         c = c - 'A' + 'a';
  600.     return (c);
  601. }
  602.  
  603.  
  604. /* the following is from news 2.11 */
  605.  
  606. #ifdef USGHIST
  607. /*
  608. ** Generate the appropriate history subfile name
  609. */
  610. char *
  611. histfile(hline)
  612. char *hline;
  613. {
  614.     char chr;    /* least significant digit of article number */
  615.     static char subfile[BUFSIZ];
  616.  
  617.     chr = findhfdigit(hline);
  618.     sprintf(subfile, "%s.d/%c", HISTORY_FILE, chr);
  619.     return subfile;
  620. }
  621.  
  622. findhfdigit(fn)
  623. char *fn;
  624. {
  625.     register char *p;
  626.     register int chr;
  627.  
  628.     p = index(fn, '@');
  629.     if (p != NULL && p > fn)
  630.         chr = *(p - 1);
  631.     else
  632.         chr = '0';
  633.     if (!isdigit(chr))
  634.         chr = '0';
  635.     return chr;
  636. }
  637. #endif /* USGHIST */
  638.  
  639. #if defined(USG) && !defined(SVR4)
  640. int
  641. dup2(x,y)
  642. int x,y;
  643. { 
  644.     close(y); 
  645.     return(fcntl(x, F_DUPFD,y ));
  646. }
  647. #endif
  648.  
  649. /*
  650.  * The following is a mish-mosh of code submitted to the net
  651.  * by Stan Barber <sob@bcm.tmc.edu>, Tad Guy <tadguy@cs.odu.edu>,
  652.  * Chris Jepeway <jepeway@utkcs2.cs.utk.edu>, and Tom Lane <tgl@cs.cmu.edu>.
  653.  */
  654.  
  655. /*
  656.  * returns 1 if there are lots of free blocks for the nntp server to use;
  657.  * a zero value is the small number of blocks remaining (more or less).
  658.  */
  659. #define DFREE_OK    0
  660. #define DFREE_INODES    1
  661. #define DFREE_BLOCKS    2
  662. #define DFREE_ERR    3
  663.  
  664. int
  665. space(min_free)
  666. int min_free;
  667. {
  668.     int result, dfree();
  669.  
  670.     result = dfree(SPOOLDIR,min_free);
  671.     if (result == DFREE_OK) return(1);
  672. #ifdef SYSLOG
  673.     switch (result) {
  674.     case DFREE_ERR:
  675.         syslog(LOG_ERR,"dfree failed due to syscall error");
  676.         break;
  677. #ifdef LOG
  678.     case DFREE_INODES:
  679.         syslog(LOG_INFO,"no inodes on %s",SPOOLDIR);
  680.         break;
  681.     case DFREE_BLOCKS:
  682.         syslog(LOG_INFO,"no space on %s",SPOOLDIR);
  683.         break;
  684. #endif
  685.         }    
  686. #endif
  687.     return(0);
  688. }
  689.  
  690. /*
  691.  * Now we define the dfree() routine, which returns the free space
  692.  * on the file system containing the specified directory.
  693.  * Space is measured in kilobytes.
  694.  * A negative value is returned on error.
  695.  */
  696. #ifndef READ_SUPER
  697. #ifndef SVR4
  698. #if defined(sun) || defined(hpux) || defined(pyr) || defined(hp300) || defined(NeXT)
  699. #include <sys/vfs.h>
  700. #define statfilesys    statfs        /* routine to call when trying to  */
  701.                     /* stat a file system to get the # */
  702.                     /* of free blocks available       */
  703. typedef struct statfs statfs_type;    /* the data type into which statfs() */
  704.                     /* wants to return useful information*/
  705. #define bombed(call)    ((call) == -1)    /* boolean expression returning 1 if */
  706.                     /* a call to statfs() fails         */
  707. #define blkfree(fs)    ((fs).f_bfree)    /* given a statfs_type, return total */
  708.                     /* # of free blocks             */
  709. #define blkavail(fs)    ((fs).f_bavail)    /* given a statfs_type called fs,  */
  710.                     /* return # of blocks available to */
  711.                     /* a non-privileged user       */
  712. #define filfree(fs)    ((fs).f_ffree)    /* given a statfs_type called fs,  */
  713.                      /* return number of free inodes       */
  714. #else
  715. #if defined(BSD_44)
  716. #include <sys/types.h>
  717. #include <sys/mount.h>
  718. #define statfilesys    statfs
  719.                     /* stat a file system to get the # */
  720.                     /* of free blocks available       */
  721. typedef struct statfs statfs_type;    /* the data type into which statfs() */
  722.                     /* wants to return useful information*/
  723. #define bombed(call)    ((call) == -1)    /* boolean expression returning 1 if */
  724.                     /* a call to statfs() fails         */
  725. #define blkfree(fs)    ((fs).f_bfree)    /* given a statfs_type, return total */
  726.                     /* # of free blocks             */
  727. #define blkavail(fs)    ((fs).f_bfree)    /* given a statfs_type called fs,  */
  728.                     /* return # of blocks available to */
  729.                     /* a non-privileged user       */
  730. #define filfree(fs)    ((fs).f_ffree)    /* given a statfs_type called fs,  */
  731.                      /* return number of free inodes       */
  732. #endif /* BSD_44 */
  733. #endif
  734. #else  /* SVR4  */
  735. #include <sys/statvfs.h>
  736. #define statfilesys    statvfs        /* routine to call when trying to  */
  737.                     /* stat a file system to get the # */
  738.                     /* of free blocks available       */
  739. typedef struct statvfs statfs_type;    /* the data type into which statfs() */
  740.                     /* wants to return useful information*/
  741. #define bombed(call)    ((call) == -1)    /* boolean expression returning 1 if */
  742.                     /* a call to statfs() fails         */
  743. #define blkfree(fs)    ((fs).f_bfree)    /* given a statfs_type, return total */
  744.                     /* # of free blocks             */
  745. #define blkavail(fs)    ((fs).f_bavail)    /* given a statfs_type called fs,  */
  746.                     /* return # of blocks available to */
  747.                     /* a non-privileged user       */
  748. #define filfree(fs)    ((fs).f_ffree)    /* given a statfs_type called fs,  */
  749.                      /* return number of free inodes       */
  750. #endif  /* SVR4 */
  751.  
  752. #if defined(apollo)
  753. #include <sys/types.h>
  754. #include <sys/statfs.h>
  755. #define statfilesys(a,b)    statfs(a,b, sizeof(struct statfs), 0)        /* routine to call when trying to  */
  756.                     /* stat a file system to get the # */
  757.                     /* of free blocks available       */
  758. typedef struct statfs statfs_type;    /* the data type into which statfs() */
  759.                     /* wants to return useful information*/
  760. #define bombed(call)    ((call) == -1)    /* boolean expression returning 1 if */
  761.                     /* a call to statfs() fails         */
  762. #define blkfree(fs)    ((fs).f_bfree)    /* given a statfs_type, return total */
  763.                     /* # of free blocks             */
  764. #define blkavail(fs)    ((fs).f_bfree)    /* given a statfs_type called fs,  */
  765.                     /* return # of blocks available to */
  766.                     /* a non-privileged user       */
  767. #define filfree(fs)    ((fs).f_ffree)    /* given a statfs_type called fs,  */
  768.                      /* return number of free inodes       */
  769. #endif /* apollo */
  770.  
  771. #ifdef ultrix
  772. #include <sys/mount.h>
  773. typedef struct fs_data statfs_type;
  774. #define statfilesys    statfs
  775. #define bombed(call)    ((call) <= 0)
  776. #define blkfree(fs)    ((int)((fs).fd_req.bfree))
  777. #define blkavail(fs)    ((int)((fs).fd_req.bfreen))
  778. #define filfree(fs)    ((int)((fs).fd_req.gfree))
  779. #endif 
  780.  
  781. #if defined(USG) && !defined(hpux) && !defined(SVR4)
  782. #include <ustat.h>
  783. typedef struct ustat statfs_type;
  784. /*
  785.  * You've got to make calls to 2 functions to get
  786.  * free blocks on a USG system, so statfilesys can't just be a macro.
  787.  * written by Stan Barber <sob@watson.bcm.tmc.edu>
  788.  */
  789. int
  790. statfilesys(dir, fs)
  791. char *dir;
  792. statfs_type *fs;
  793. {
  794.     struct stat file;
  795.     if (stat(dir,&file)) return(-1);
  796.     if (ustat(file.st_dev, fs)) return(-2);
  797.     return(0);
  798. }
  799. #define bombed(call)    (call != 0)
  800. #define blkfree(fs)    ((fs).f_tfree)
  801. #define blkavail(fs)    ((fs).f_tfree)
  802.                 /* USG doesn't reserve blocks for root */
  803. #define filfree(fs)    ((fs).f_tinode)    
  804. #endif /* USG && !hpux  && !SVR4 */
  805.  
  806. #ifdef CMU_MACH
  807. /* This code supplied by Tom Lane <tgl@cs.cmu.edu> */
  808. #include <sys/ioctl.h>
  809. typedef struct fsparam statfs_type;
  810. int
  811. statfilesys(dir, fs)
  812. char *dir;
  813. statfs_type *fs;
  814. {
  815.     int fd;
  816.     fd = open(dir, O_RDONLY);
  817.     if (fd < 0) return(-1);
  818.     if (ioctl(fd, FIOCFSPARAM, fs) < 0) {
  819.     close(fd);
  820.     return(-2);
  821.     }
  822.     close(fd);
  823.     return(0);
  824. }
  825. #define bombed(call)    ((call) < 0)
  826. #define blkfree(fs)    ((fs).fsp_free-((fs).fsp_size*(fs).fsp_minfree+99)/100)
  827. #define blkavail(fs)    (-1)
  828. #endif /* CMU_MACH */
  829.  
  830. int
  831. dfree(spool,free_space)
  832. char *spool;
  833. int free_space;
  834. {
  835. #ifndef amiga
  836.     statfs_type fsys;
  837.     int err;
  838.  
  839.     if (bombed(err = statfilesys(SPOOLDIR, &fsys)))
  840.     return(DFREE_ERR);        /* can't get file system info */
  841. # if defined(filfree) && defined(MINFILES)
  842.      if (filfree(fsys) < MINFILES )
  843.      return( DFREE_INODES );
  844. # endif
  845.     if (blkavail(fsys) < 0L) {
  846.     /* the bavail field doesn't apply to this file system */
  847.     if(blkfree(fsys) < free_space)
  848.         return( DFREE_BLOCKS );
  849.      } else {
  850.     if (blkavail(fsys) < free_space )
  851.         return( DFREE_BLOCKS );
  852.      }
  853. #endif
  854.     return( DFREE_OK );
  855. }
  856.  
  857. #else /* READ_SUPER */
  858. /*
  859.  * This code is used if you've got to directly read the superblock
  860.  * to determine how much space you've got left.  It's copied from
  861.  * patches posted by Tad Guy <tadguy@cs.odu.edu>
  862.  */
  863.  
  864. #include <sys/fs.h>
  865. #include <fstab.h>
  866.  
  867. /*
  868.  * return the number of free kilobytes remaining on the filesystem where
  869.  * the named file resides.  returns -1 on error.
  870.  */
  871.  
  872. off_t lseek();
  873.  
  874. dfree(name, free_space)
  875. char *name;
  876. int free_space;
  877. {
  878.     struct stat namest, fsst;
  879.     struct fstab *fsp;
  880.     char lname[MAXPATHLEN];
  881.     int fd;
  882.     union {
  883.     struct fs u_fs;
  884.     char dummy[SBSIZE];
  885.     } sb;
  886. #define sblock sb.u_fs
  887.  
  888.     strcpy(lname,name);
  889.     do {
  890.     if (stat(lname,&namest))        /* if stat fails, die */
  891.     {
  892. #ifdef SYSLOG
  893.       syslog(LOG_ERR,"dfree stat(%s) failed: %m", lname);
  894. #endif
  895.       return  DFREE_ERR;            
  896.     }
  897.     if ((namest.st_mode & S_IFMT) == S_IFLNK) { /* if symlink */
  898.         if ((fd = readlink(lname,lname,sizeof(lname))) < 0) 
  899.         {
  900. #ifdef SYSLOG
  901.           syslog(LOG_ERR,"dfree readlink() failed: %m");
  902. #endif
  903.           return DFREE_ERR;
  904.         }
  905.         lname[fd] = '\0';
  906.     }
  907.     } while ((namest.st_mode & S_IFMT) == S_IFLNK);
  908.  
  909.     (void) setfsent();
  910.  
  911.     while (fsp = getfsent()) {
  912.     if (stat(fsp->fs_spec,&fsst))
  913.       continue;
  914.     if (fsst.st_rdev == namest.st_dev)
  915.       break;
  916.     }
  917.  
  918.     if (!fsp ||    (fd = open(fsp->fs_spec,O_RDONLY)) < 0) {
  919.     (void) endfsent();
  920. #ifdef SYSLOG
  921.     syslog(LOG_ERR,"dfree open(%s,O_RDONLY) failed: %m", fsp->fs_spec);
  922. #endif
  923.     return DFREE_ERR;
  924.     }
  925.     (void) endfsent();
  926.  
  927.     (void) lseek(fd,SBLOCK*DEV_BSIZE,L_SET);
  928.     if (read(fd,(char *)&sblock,SBSIZE) != SBSIZE ||
  929.     (sblock.fs_magic != FS_MAGIC))
  930.     {
  931. #ifdef SYSLOG
  932.       syslog(LOG_ERR,"dfree read() failed: %m");
  933. #endif
  934.       return DFREE_ERR;
  935.     }
  936.     (void) close(fd);
  937.  
  938. # if defined(filfree) && defined(MINFILES)
  939.     if (filfree(fsys) < MINFILES )
  940.     return( DFREE_INODES );
  941. # endif
  942.     if( ((((sblock.fs_dsize) * ( 100 - sblock.fs_minfree) / 100)
  943.       - ((sblock.fs_dsize) 
  944.          - (sblock.fs_cstotal.cs_nbfree 
  945.         * sblock.fs_frag + sblock.fs_cstotal.cs_nffree))) 
  946.      * sblock.fs_fsize / 1024) < free_space )
  947.     return( DFREE_BLOCKS );
  948.    return( DFREE_OK );
  949. }
  950.  
  951. #endif /* READ_SUPER */
  952.  
  953. #ifdef LOAD
  954. /*
  955. **  GETLA -- get the current load average
  956. **
  957. **    This code stolen from la.c. (And subsequently stolen from sendmail,
  958. **        conf.c for nntpd.)
  959. **
  960. **    Parameters:
  961. **        none.
  962. **
  963. **    Returns:
  964. **        The current load average as an integer.
  965. **
  966. **    Side Effects:
  967. **        none.
  968. */
  969.  
  970. #if defined(USG) && !defined(SVR4)
  971. int
  972. getla()
  973. {
  974.     return(0);
  975. }
  976. #else
  977. #include <nlist.h>
  978. #include <sys/ioctl.h>
  979.  
  980. struct    nlist Nl[] =
  981. {
  982. #ifdef SVR4
  983.     { "avenrun" },
  984. #else
  985. #ifdef bsdi
  986.     { "_averunnable" },
  987. #else
  988.     { "_avenrun" },
  989. #endif
  990. #endif
  991. #define    X_AVENRUN    0
  992.     { 0 },
  993. };
  994.  
  995. #ifdef SVR4
  996. #define KERNEL_FILE "/unix"
  997. #else
  998. #ifdef bsdi
  999. #define KERNEL_FILE "/bsd"
  1000. #else
  1001. #define KERNEL_FILE "/vmunix"
  1002. #endif
  1003. #endif
  1004.  
  1005. #ifdef    SVR4
  1006. #ifndef FSHIFT
  1007. #define FSHIFT  8
  1008. #endif
  1009. #ifndef FSCALE
  1010. #define FSCALE  (1 << FSHIFT)
  1011. #endif
  1012. #endif
  1013.  
  1014. int
  1015. getla()
  1016. {
  1017.     static int kmem = -1;
  1018. # ifdef FSCALE
  1019.     long avenrun[3];
  1020. # else
  1021.     double avenrun[3];
  1022. # endif
  1023.     extern off_t lseek();
  1024.  
  1025.     if (kmem < 0) {
  1026.         kmem = open("/dev/kmem", 0, 0);
  1027.         if (kmem < 0) {
  1028. #ifdef SYSLOG
  1029.             syslog(LOG_ERR,"can't open /dev/kmem: %m");
  1030. #endif
  1031.             return (-1);
  1032.         }
  1033. #ifndef SVR4
  1034.         if (ioctl(kmem, (int) FIOCLEX, (char *) 0) < 0) {
  1035. #ifdef SYSLOG
  1036.             syslog(LOG_ERR,"ioctl FIOCLEX of /dev/kmem failed: %m");
  1037. #endif
  1038.         }
  1039. #endif /* !SVR4 */
  1040.         if (nlist(KERNEL_FILE, Nl) < 0 || Nl[X_AVENRUN].n_value == 0) {
  1041. #ifdef SYSLOG
  1042.             syslog(LOG_ERR,"nlist of %s failed: %m", KERNEL_FILE);
  1043. #endif
  1044.             return (-1);
  1045.         }
  1046.     }
  1047.     if (lseek(kmem, (off_t) Nl[X_AVENRUN].n_value, 0) == -1 ||
  1048.         read(kmem, (char *) avenrun, sizeof(avenrun)) < sizeof(avenrun))
  1049.     {
  1050.         /* thank you Ian */
  1051. #ifdef SYSLOG
  1052.         syslog(LOG_ERR,"lseek or read of /dev/kmem failed: %m");
  1053. #endif
  1054.         return (-1);
  1055.     }
  1056. # ifdef FSCALE
  1057.     return ((int) (avenrun[0] + FSCALE/2) >> FSHIFT);
  1058. # else
  1059.     return ((int) (avenrun[0] + 0.5));
  1060. # endif
  1061. }
  1062. #endif
  1063. #endif /* LOAD */
  1064.